home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / applets / collectn / interlea.jav < prev    next >
Text File  |  1995-10-22  |  3KB  |  134 lines
  1. /*
  2.   File: InterleavingEnumeration.java
  3.  
  4.   Originally written by Doug Lea and released into the public domain. 
  5.   Thanks for the assistance and support of Sun Microsystems Labs, Agorics 
  6.   Inc, Loral, and everyone contributing, testing, and using this code.
  7.  
  8.   History:
  9.   Date     Who                What
  10.   22Oct95  dl@cs.oswego.edu   Created.
  11.  
  12. */
  13.   
  14. package collections;
  15.  
  16. import java.util.Enumeration;
  17. import java.util.NoSuchElementException;
  18.  
  19. /**
  20.  *
  21.  * InterleavingEnumerations allow you to combine the elements
  22.  * of two different enumerations as if they were one enumeration
  23.  * before they are seen by their `consumers'.
  24.  * This sometimes allows you to avoid having to use a 
  25.  * Collection object to temporarily combine two sets of Collection elements()
  26.  * that need to be collected together for common processing.
  27.  * <P>
  28.  * The elements are revealed (via nextElement()) in a purely
  29.  * interleaved fashion, alternating between the first and second
  30.  * enumerations unless one of them has been exhausted, in which case
  31.  * all remaining elements of the other are revealed until it too is
  32.  * exhausted. 
  33.  * <P>
  34.  * InterleavingEnumerations work as wrappers around other Enumerations.
  35.  * To build one, you need two existing Enumerations.
  36.  * For example, if you want to process together the elements of
  37.  * two Collections a and b, you could write something of the form:
  38.  * <PRE>
  39.  * Enumeration items = InterleavingEnumeration(a.elements(), b.elements());
  40.  * while (items.hasMoreElements()) 
  41.  *  doSomethingWith(items.nextElement());
  42.  * </PRE>
  43.  * @author Doug Lea
  44.  * @version 0.93
  45.  *
  46.  * <P> For an introduction to this package see <A HREF="index.html"> Overview </A>.
  47.  *
  48. **/
  49.  
  50.  
  51. public class InterleavingEnumeration implements Enumeration {
  52.  
  53. /**
  54.  * The first source; nulled out once it is exhausted
  55. **/
  56.  
  57.   private Enumeration fst_;
  58.  
  59. /**
  60.  * The second source; nulled out once it is exhausted
  61. **/
  62.  
  63.   private Enumeration snd_;
  64.  
  65. /**
  66.  * The source currently being used
  67. **/
  68.  
  69.   private Enumeration current_;
  70.  
  71.  
  72.  
  73. /**
  74.  * Make an enumeration interleaving elements from fst and snd
  75. **/
  76.  
  77.   public InterleavingEnumeration(Enumeration fst, Enumeration snd) {
  78.     fst_ = fst;
  79.     snd_ = snd;
  80.     current_ = snd_; // flip will reset to fst (if it can)
  81.     flip();
  82.   }
  83.  
  84. /**
  85.  * Implements java.util.Enumeration.hasMoreElements
  86. **/
  87.   public synchronized boolean hasMoreElements() { 
  88.     return current_ != null;
  89.   }
  90.  
  91. /**
  92.  * Implements java.util.Enumeration.nextElement.
  93. **/
  94.   public synchronized Object nextElement() {
  95.     if (!hasMoreElements())
  96.       throw new NoSuchElementException("exhausted enumeration");
  97.     else {
  98.       // following line may also throw ex, but there's nothing 
  99.       // reasonable to do except propagate
  100.       Object result = current_.nextElement(); 
  101.       flip();
  102.       return result;
  103.     }
  104.   }
  105.  
  106. /**
  107.  * Alternate sources
  108. **/
  109.  
  110.   private void flip() {
  111.     if (current_ == fst_) {
  112.       if (snd_ != null && !snd_.hasMoreElements()) snd_ = null;
  113.       if (snd_ != null)
  114.         current_ = snd_;
  115.       else {
  116.         if (fst_ != null && !fst_.hasMoreElements()) fst_ = null;
  117.         current_ = fst_;
  118.       }
  119.     }
  120.     else {
  121.       if (fst_ != null && !fst_.hasMoreElements()) fst_ = null;
  122.       if (fst_ != null) 
  123.         current_ = fst_;
  124.       else {
  125.         if (snd_ != null && !snd_.hasMoreElements()) snd_ = null;
  126.         current_ = snd_;
  127.       }
  128.     }
  129.   }
  130.  
  131.  
  132. }
  133.   
  134.